use crate::error::Result; 
use crate::compiler::{ASTNode}; 
use crate::vm::{Instruction, Value}; 
use crate::advanced_optimizations::{OptimizationManager, OptimizationLevel};

#[cfg(feature = "jit")]
use crate::jit::{PipitJIT, JITOptimizationLevel};

/// 编译器后端：负责程序优化和代码生成
pub struct CompilerBackend {
    // 代码生成器
    code_generator: CodeGenerator,
    // 优化管理器
    optimization_manager: OptimizationManager,
    // 优化级别
    optimization_level: OptimizationLevel,
    
    // JIT编译器（可选）
    #[cfg(feature = "jit")]
    jit_compiler: Option<PipitJIT>,
    
    // 优化标志
    aggressive_inlining: bool,
    simd_optimizations: bool,
}

impl CompilerBackend {
    pub fn new(optimization_level: OptimizationLevel, _enable_jit: bool) -> Self {
        let backend = CompilerBackend {
            code_generator: CodeGenerator::new(),
            optimization_manager: OptimizationManager::new(optimization_level),
            optimization_level,
            
            #[cfg(feature = "jit")]
            jit_compiler: None,
            
            // 默认优化标志
            aggressive_inlining: optimization_level == OptimizationLevel::Aggressive,
            simd_optimizations: true,
        };
        
        // 如果启用JIT，则初始化JIT编译器
        #[cfg(feature = "jit")]
        if _enable_jit {
            let jit_level = match optimization_level {
                OptimizationLevel::None => JITOptimizationLevel::None,
                OptimizationLevel::Basic => JITOptimizationLevel::Basic,
                OptimizationLevel::Medium => JITOptimizationLevel::Aggressive,  // 对Medium级别也使用Aggressive JIT优化
                OptimizationLevel::Aggressive => JITOptimizationLevel::Aggressive,
            };
            backend.jit_compiler = Some(PipitJIT::new(jit_level));
        }
        
        backend
    }
    
    /// 从AST生成优化后的字节码
    pub fn generate_optimized_bytecode(&mut self, ast: Box<ASTNode>) -> Result<Vec<Instruction>> {
        // 第一步：生成未优化的字节码
        let mut bytecode = self.code_generator.generate_bytecode(ast)?;
        
        // 添加程序结束指令
        bytecode.push(Instruction::Halt);
        
        // 第二步：根据优化级别应用不同级别的优化
        match self.optimization_level {
            OptimizationLevel::None => {}, // 不进行优化
            OptimizationLevel::Basic => bytecode = self.apply_basic_optimizations(bytecode)?,
            OptimizationLevel::Medium => {
                bytecode = self.apply_basic_optimizations(bytecode)?;
                bytecode = self.apply_medium_optimizations(bytecode)?;
            },
            OptimizationLevel::Aggressive => {
                bytecode = self.apply_basic_optimizations(bytecode)?;
                bytecode = self.apply_medium_optimizations(bytecode)?;
                bytecode = self.apply_aggressive_optimizations(bytecode)?;
            },
        }
        
        // 如果启用了JIT，可以在这里进行预编译
        #[cfg(feature = "jit")]
        if let Some(jit) = &mut self.jit_compiler {
            // 将字节码转换为JIT可以处理的格式
            // 注意：暂时注释掉这部分，bincode未成为正式项目依赖
            // let bytecode_bytes: Vec<u8> = bytecode.iter()
            //     .flat_map(|instr| bincode::serialize(instr))
            //     .collect::<Result<_, _>>()
            //     .map_err(|e| PipitError::CompileError(format!("Failed to serialize bytecode: {}", e)))?;
            
            // // 预编译主程序
            // if let Err(err) = jit.precompile_module("main", &bytecode_bytes) {
            //     eprintln!("JIT precompilation warning: {}", err);
            //     // 即使JIT失败，也继续执行
            // }
        }
        
        Ok(bytecode)
    }
    
    /// 应用基本优化
    fn apply_basic_optimizations(&mut self, bytecode: Vec<Instruction>) -> Result<Vec<Instruction>> {
        // 实现基本优化，如常量折叠、死代码消除等
        let mut optimizer = BasicBytecodeOptimizer::new();
        optimizer.optimize(bytecode)
    }
    
    /// 应用中级优化
    fn apply_medium_optimizations(&mut self, bytecode: Vec<Instruction>) -> Result<Vec<Instruction>> {
        // 实现中级优化，如循环不变式提取、公共子表达式消除等
        let mut optimizer = MediumBytecodeOptimizer::new();
        optimizer.optimize(bytecode)
    }
    
    /// 应用激进优化
    fn apply_aggressive_optimizations(&mut self, bytecode: Vec<Instruction>) -> Result<Vec<Instruction>> {
        // 实现激进优化，如函数内联、多态内联缓存等
        let mut optimizer = AggressiveBytecodeOptimizer::new();
        
        // 根据backend配置设置优化器的激进内联选项
        optimizer.set_aggressive_inlining(self.aggressive_inlining);
        
        optimizer.optimize(bytecode)
    }
    
    /// 获取JIT编译器引用（如果启用）
    #[cfg(feature = "jit")]
    pub fn get_jit_compiler(&self) -> Option<&PipitJIT> {
        self.jit_compiler.as_ref()
    }
    
    /// 获取JIT编译器可变引用（如果启用）
    #[cfg(feature = "jit")]
    pub fn get_jit_compiler_mut(&mut self) -> Option<&mut PipitJIT> {
        self.jit_compiler.as_mut()
    }
    
    /// 当JIT特性未启用时提供空实现
    #[cfg(not(feature = "jit"))]
    pub fn get_jit_compiler(&self) -> Option<()> {
        None
    }
    
    /// 当JIT特性未启用时提供空实现
    #[cfg(not(feature = "jit"))]
    pub fn get_jit_compiler_mut(&mut self) -> Option<()> {
        None
    }
    
    /// 获取当前的优化级别
    pub fn get_optimization_level(&self) -> OptimizationLevel {
        self.optimization_level
    }
    
    /// 设置优化级别
    pub fn set_optimization_level(&mut self, level: OptimizationLevel) {
        self.optimization_level = level;
        self.optimization_manager = OptimizationManager::new(level);
        
        // 同时更新JIT优化级别
        #[cfg(feature = "jit")]
        if self.jit_compiler.is_some() {
            let jit_level = match level {
                OptimizationLevel::None => JITOptimizationLevel::None,
                OptimizationLevel::Basic => JITOptimizationLevel::Basic,
                OptimizationLevel::Medium => JITOptimizationLevel::Aggressive,  // 对Medium级别也使用Aggressive JIT优化
                OptimizationLevel::Aggressive => JITOptimizationLevel::Aggressive,
            };
            // 通过创建新实例来更新JIT优化级别
            self.jit_compiler = Some(PipitJIT::new(jit_level));
        }
    }
    
    /// 启用或禁用激进内联
    pub fn enable_aggressive_inlining(&mut self, enable: bool) {
        self.aggressive_inlining = enable;
        // 同时更新优化级别（如果启用激进内联，至少需要Medium级别）
        if enable && self.optimization_level == OptimizationLevel::Basic {
            self.set_optimization_level(OptimizationLevel::Medium);
        }
    }
    
    /// 启用或禁用SIMD优化
    pub fn enable_simd_optimizations(&mut self, enable: bool) {
        self.simd_optimizations = enable;
        // SIMD优化通常需要至少Medium级别
        if enable && self.optimization_level == OptimizationLevel::Basic {
            self.set_optimization_level(OptimizationLevel::Medium);
        }
    }
    
    /// 检查是否启用了激进内联
    pub fn is_aggressive_inlining_enabled(&self) -> bool {
        self.aggressive_inlining
    }
    
    /// 检查是否启用了SIMD优化
    pub fn is_simd_optimizations_enabled(&self) -> bool {
        self.simd_optimizations
    }
}

/// 字节码生成器
pub struct CodeGenerator {
    // 内部使用原始的Compiler进行字节码生成
    inner_compiler: crate::compiler::Compiler,
}

impl CodeGenerator {
    pub fn new() -> Self {
        CodeGenerator {
            inner_compiler: crate::compiler::Compiler::new(),
        }
    }
    
    /// 从AST生成字节码
    pub fn generate_bytecode(&mut self, ast: Box<ASTNode>) -> Result<Vec<Instruction>> {
        // 重置编译器状态
        self.inner_compiler.reset();
        
        // 直接调用内部的generate_bytecode方法来处理AST
        self.inner_compiler.generate_bytecode(&ast)?;
        
        // 返回字节码副本
        Ok(self.inner_compiler.get_bytecode_clone())
    }
}

/// 基本字节码优化器
pub struct BasicBytecodeOptimizer {
    // 优化器状态
}

impl BasicBytecodeOptimizer {
    pub fn new() -> Self {
        BasicBytecodeOptimizer {}
    }
    
    // 常量折叠 - 优化连续的常量操作指令
    fn constant_folding(&self, instructions: &mut Vec<Instruction>) {
        let mut i = 0;
        while i < instructions.len() {
            // 检查是否有连续的Push和数学运算指令可以优化
            if i + 2 < instructions.len() {
                match (&instructions[i], &instructions[i+1], &instructions[i+2]) {
                    (Instruction::Push(Value::Integer(a)), 
                     Instruction::Push(Value::Integer(b)), 
                     Instruction::Add) => {
                        // 替换为一个Push指令
                        let result = Value::Integer(a + b);
                        instructions[i] = Instruction::Push(result);
                        instructions.remove(i+1);
                        instructions.remove(i+1);
                        // 不增加i，因为可能有新的优化机会
                    },
                    (Instruction::Push(Value::Integer(a)), 
                     Instruction::Push(Value::Integer(b)), 
                     Instruction::Sub) => {
                        let result = Value::Integer(a - b);
                        instructions[i] = Instruction::Push(result);
                        instructions.remove(i+1);
                        instructions.remove(i+1);
                    },
                    (Instruction::Push(Value::Integer(a)), 
                     Instruction::Push(Value::Integer(b)), 
                     Instruction::Mul) => {
                        let result = Value::Integer(a * b);
                        instructions[i] = Instruction::Push(result);
                        instructions.remove(i+1);
                        instructions.remove(i+1);
                    },
                    (Instruction::Push(Value::Integer(a)), 
                     Instruction::Push(Value::Integer(b)), 
                     Instruction::Div) if *b != 0 => {
                        let result = Value::Integer(a / b);
                        instructions[i] = Instruction::Push(result);
                        instructions.remove(i+1);
                        instructions.remove(i+1);
                    },
                    _ => {
                        i += 1;
                    }
                }
            } else {
                i += 1;
            }
        }
    }
    
    // 死代码消除 - 移除不可达的代码
    fn dead_code_elimination(&self, instructions: &mut Vec<Instruction>) {
        if instructions.is_empty() {
            return;
        }
        
        // 识别跳转目标
        let mut reachable = vec![false; instructions.len()];
        let mut stack = vec![0];
        
        // 标记可达代码
        while let Some(idx) = stack.pop() {
            if idx < instructions.len() && !reachable[idx] {
                reachable[idx] = true;
                
                // 处理跳转指令
                match &instructions[idx] {
                    Instruction::Jump(target) => {
                        if *target < instructions.len() && !reachable[*target] {
                            stack.push(*target);
                        }
                    },
                    Instruction::JumpIfFalse(target) | 
                    Instruction::JumpIfTrue(target) => {
                        // 条件跳转，两个分支都要检查
                        if *target < instructions.len() && !reachable[*target] {
                            stack.push(*target);
                        }
                        // 继续下一条指令
                        if idx + 1 < instructions.len() && !reachable[idx + 1] {
                            stack.push(idx + 1);
                        }
                    },
                    Instruction::Halt | Instruction::Return => {
                        // 这些指令后不会执行其他代码
                    },
                    _ => {
                        // 其他指令，继续下一条
                        if idx + 1 < instructions.len() && !reachable[idx + 1] {
                            stack.push(idx + 1);
                        }
                    }
                }
            }
        }
        
        // 移除不可达的代码
        let mut i = 0;
        while i < instructions.len() {
            if !reachable[i] {
                instructions.remove(i);
                // 调整可达性标记
                for j in i..reachable.len() - 1 {
                    reachable[j] = reachable[j + 1];
                }
                reachable.pop();
            } else {
                i += 1;
            }
        }
    }
    
    // 栈操作优化 - 合并连续的栈操作
    fn stack_optimization(&self, instructions: &mut Vec<Instruction>) {
        // 栈优化逻辑需要根据实际的指令集重新实现
        // 目前Instruction枚举中没有Pop指令，所以简化此方法
        let mut i = 0;
        while i < instructions.len() {
            // 移除多余的Nop指令
            if let Instruction::Nop = instructions[i] {
                instructions.remove(i);
            } else {
                i += 1;
            }
        }
    }
    
    pub fn optimize(&mut self, mut bytecode: Vec<Instruction>) -> Result<Vec<Instruction>> {
        // 实现常量折叠
        self.constant_folding(&mut bytecode);
        
        // 实现死代码消除
        self.dead_code_elimination(&mut bytecode);
        
        // 实现栈操作优化
        self.stack_optimization(&mut bytecode);
        
        Ok(bytecode)
    }
}

/// 中级字节码优化器
pub struct MediumBytecodeOptimizer {
    // 优化器状态
    basic_optimizer: BasicBytecodeOptimizer,
}

impl MediumBytecodeOptimizer {
    pub fn new() -> Self {
        MediumBytecodeOptimizer {
            basic_optimizer: BasicBytecodeOptimizer::new(),
        }
    }
    
    // 循环不变式提取 - 将循环中不会改变的表达式移到循环外
    fn loop_invariant_hoisting(&self, instructions: &mut Vec<Instruction>) {
        // 识别循环结构
        let mut loops = Vec::new();
        
        // 简单循环检测：寻找向后跳转形成的循环
        for i in 0..instructions.len() {
            if let Instruction::Jump(target) = &instructions[i] {
                if *target < i && i - *target > 3 { // 确保循环有一定大小
                    loops.push((*target, i));
                }
            }
        }
        
        // 对每个循环进行优化
        for (start, end) in loops {
            // 寻找循环内的不变式
            let mut invariants = Vec::new();
            
            // 分析循环内的指令
            for i in start..end {
                if let Instruction::Push(Value::Integer(_)) | 
                   Instruction::Push(Value::Float(_)) | 
                   Instruction::Push(Value::Boolean(_)) | 
                   Instruction::Push(Value::String(_)) = &instructions[i] {
                    // 常量值是不变式
                    invariants.push(i);
                }
            }
            
            // 将不变式移到循环开始前
            if !invariants.is_empty() {
                let mut insert_pos = start;
                let mut offset = 0;
                
                // 按顺序移动不变式
                for idx in invariants {
                    let actual_idx = idx + offset;
                    if actual_idx > start {
                        let invariant = instructions.remove(actual_idx);
                        instructions.insert(insert_pos, invariant);
                        insert_pos += 1;
                        offset -= 1;
                    }
                }
            }
        }
    }
    
    // 寄存器分配 - 优化寄存器的使用
    fn register_allocation(&self, instructions: &mut Vec<Instruction>) {
        // 简单的寄存器分配策略：将频繁使用的栈变量移至寄存器
        
        // 统计栈操作 - 适配实际指令集（没有Pop指令）
        let mut stack_depth = 0;
        let mut stack_usage = Vec::new();
        
        for instr in &*instructions {
            match instr {
                Instruction::Push(_) => {
                    stack_depth += 1;
                    stack_usage.push(stack_depth);
                },
                // 识别可能减少栈深度的指令
                Instruction::Add | Instruction::Sub | Instruction::Mul | Instruction::Div | 
                Instruction::Mod | Instruction::Pow | Instruction::Equal | Instruction::LessThan | 
                Instruction::GreaterThan | Instruction::And | Instruction::Or => {
                    // 二元操作通常消耗两个操作数，产生一个结果
                    if stack_depth >= 2 {
                        stack_depth -= 1;
                    }
                    stack_usage.push(stack_depth);
                },
                Instruction::Not => {
                    // 一元操作消耗一个操作数，产生一个结果
                    stack_usage.push(stack_depth);
                },
                Instruction::Call(_) => {
                    // 函数调用可能改变栈深度，但这里简化处理
                    stack_usage.push(stack_depth);
                },
                Instruction::Return => {
                    // 函数返回可能改变栈深度，但这里简化处理
                    stack_usage.push(stack_depth);
                },
                _ => {
                    stack_usage.push(stack_depth);
                }
            }
        }
        
        // 对于栈使用较高的区域，尝试优化
        let mut to_modify = Vec::new();
        let mut i = 0;
        while i + 3 < instructions.len() {
            // 先收集要修改的信息，避免同时持有可变和不可变引用
            if i + 3 < instructions.len() {
                // 使用match代替不稳定的if let模式
                match (&instructions[i], &instructions[i+1], &instructions[i+2], &instructions[i+3]) {
                    (Instruction::Push(v), 
                     Instruction::StoreVar(idx), 
                     Instruction::LoadVar(idx2), 
                     _) if idx == idx2 => {
                        to_modify.push((i, v.clone(), *idx));
                    },
                    _ => {}
                }
            }
            i += 1;
        }
        
        // 应用修改，从后往前修改以避免索引偏移问题
        for (pos, value, _idx) in to_modify.iter().rev() {
            let reg = 0; // 使用第一个可用寄存器
            instructions[*pos] = Instruction::RegLoadConst(reg, value.clone());
            // 保留存储到变量的操作
            // 移除LoadVar指令
            instructions.remove(*pos + 2);
        }
    }
    
    // 常见子表达式消除
    fn common_subexpression_elimination(&self, instructions: &mut Vec<Instruction>) {
        // 简单实现：识别连续的相同表达式
        let mut i = 0;
        while i + 3 < instructions.len() {
            // 检查是否有相同的表达式序列
            let mut match_len = 0;
            while i + match_len * 2 + 3 < instructions.len() {
                let pattern = &instructions[i..i+match_len+3];
                let candidate = &instructions[i+match_len+3..i+match_len*2+6];
                
                if pattern == candidate && match_len < 3 { // 限制匹配长度
                    match_len += 1;
                } else {
                    break;
                }
            }
            
            if match_len > 0 {
                // 找到了公共子表达式，使用寄存器暂存结果
                let reg = 0; // 使用第一个可用寄存器
                
                // 保留第一个表达式
                // 插入存储结果到寄存器的指令
                instructions.insert(i+match_len+3, Instruction::RegisterToStack(reg));
                
                // 用从寄存器加载的指令替换第二个表达式
                for _ in 0..match_len*2+3 {
                    instructions.remove(i+match_len+4);
                }
                instructions.insert(i+match_len+4, Instruction::StackToRegister(0, reg));
            }
            
            i += 1;
        }
    }
    
    pub fn optimize(&mut self, mut bytecode: Vec<Instruction>) -> Result<Vec<Instruction>> {
        // 先应用基本优化
        bytecode = self.basic_optimizer.optimize(bytecode)?;
        
        // 实现循环不变式提取
        self.loop_invariant_hoisting(&mut bytecode);
        
        // 实现寄存器分配
        self.register_allocation(&mut bytecode);
        
        // 实现常见子表达式消除
        self.common_subexpression_elimination(&mut bytecode);
        
        Ok(bytecode)
    }
}

/// 激进字节码优化器
pub struct AggressiveBytecodeOptimizer {
    // 优化器状态
    medium_optimizer: MediumBytecodeOptimizer,
    inline_threshold: usize, // 内联阈值（字节码指令数）
    enable_aggressive_inlining: bool, // 是否启用激进内联
}

impl AggressiveBytecodeOptimizer {
    pub fn new() -> Self {
        AggressiveBytecodeOptimizer {
            medium_optimizer: MediumBytecodeOptimizer::new(),
            inline_threshold: 20, // 小函数的指令数阈值
            enable_aggressive_inlining: true, // 默认启用激进内联
        }
    }
    
    /// 启用或禁用激进内联
    pub fn set_aggressive_inlining(&mut self, enable: bool) {
        self.enable_aggressive_inlining = enable;
    }
    
    // 函数内联 - 将小函数的代码直接插入调用点
    fn function_inlining(&self, instructions: &mut Vec<Instruction>) {
        // 检查是否启用了激进内联
        if !self.enable_aggressive_inlining {
            return;
        }
        
        // 简单实现：识别对小函数的调用并内联
        let mut i = 0;
        while i < instructions.len() {
            if let Instruction::Call(func_index) = &instructions[i] {
                // 这里简化处理，实际应该获取函数定义并检查大小
                // 由于当前接口限制，我们假设小索引函数是小函数
                if *func_index < 10 { // 假设前10个函数是小函数
                    // 准备内联：这里只是模拟内联效果
                    // 在实际实现中，应该获取函数定义并插入其指令
                    instructions[i] = Instruction::Nop; // 暂时用Nop代替
                }
            }
            i += 1;
        }
    }
    
    // 类型特化 - 根据实际参数类型优化函数调用
    fn type_specialization(&self, instructions: &mut Vec<Instruction>) {
        // 简单实现：基于已知的参数类型进行优化
        let mut i = 0;
        while i + 2 < instructions.len() {
            // 检查常见的类型模式
            if let (Instruction::Push(Value::Integer(_)), 
                     Instruction::Push(Value::Integer(_)), 
                     Instruction::Add) = 
                (&instructions[i], &instructions[i+1], &instructions[i+2]) {
                // 对于两个整数的加法，可以使用更高效的指令序列
                // 这里我们只是标记这个位置，实际实现应该替换为优化的指令
                instructions.insert(i+3, Instruction::Nop); // 暂时用Nop标记
            }
            i += 1;
        }
    }
    
    // 尾递归优化 - 将尾递归转换为循环
    fn tail_recursion_optimization(&self, instructions: &mut Vec<Instruction>) {
        // 识别并优化尾递归调用
        let mut i = 0;
        while i + 1 < instructions.len() {
            // 简单模式：Call后紧跟Return
            if let (Instruction::Call(_call_idx), Instruction::Return) = 
                (&instructions[i], &instructions[i+1]) {
                // 这里简化处理，实际应该检查是否是递归调用
                // 将尾递归替换为跳转到函数开始
                instructions[i] = Instruction::Jump(0); // 跳转到函数开始
                instructions.remove(i+1); // 移除Return
            }
            i += 1;
        }
    }
    
    pub fn optimize(&mut self, mut bytecode: Vec<Instruction>) -> Result<Vec<Instruction>> {
        // 先应用中级优化
        bytecode = self.medium_optimizer.optimize(bytecode)?;
        
        // 注意：以下优化方法目前是简化的模拟实现，可能会破坏指令顺序
        // 为了确保字节码的正确性，暂时不应用这些优化
        // 
        // 实现函数内联 - 暂时禁用
        // if self.enable_aggressive_inlining {
        //     self.function_inlining(&mut bytecode);
        // }
        // 
        // 实现类型特化 - 暂时禁用
        // self.type_specialization(&mut bytecode);
        // 
        // 实现尾递归优化 - 暂时禁用
        // self.tail_recursion_optimization(&mut bytecode);
        
        Ok(bytecode)
    }
}

// 注意：Instruction枚举中已经添加了Nop指令，这里只是为了完整性保留